Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface ChainableCommander

Hierarchy

  • RedisCommander<{ type: "pipeline" }>
    • ChainableCommander

Index

Properties

Methods

Properties

length: number

Methods

  • acl(subcommand: "CAT", callback?: Callback<unknown>): ChainableCommander
  • acl(subcommand: "CAT", category: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): ChainableCommander
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): ChainableCommander
  • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): ChainableCommander
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): ChainableCommander
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
  • acl(subcommand: "GENPASS", callback?: Callback<string>): ChainableCommander
  • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): ChainableCommander
  • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): ChainableCommander
  • acl(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • acl(subcommand: "LIST", callback?: Callback<string[]>): ChainableCommander
  • acl(subcommand: "LOAD", callback?: Callback<"OK">): ChainableCommander
  • acl(subcommand: "LOG", callback?: Callback<unknown>): ChainableCommander
  • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): ChainableCommander
  • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): ChainableCommander
  • acl(subcommand: "SAVE", callback?: Callback<"OK">): ChainableCommander
  • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): ChainableCommander
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): ChainableCommander
  • acl(subcommand: "USERS", callback?: Callback<string[]>): ChainableCommander
  • acl(subcommand: "WHOAMI", callback?: Callback<string>): ChainableCommander
  • Lists the ACL categories, or the commands inside a category.

    • group: server
    • complexity: O(1) since the categories and commands are a fixed set.
    • since: 6.0.0

    Parameters

    • subcommand: "CAT"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CAT"
    • category: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Deletes ACL users, and terminates their connections.

    • group: server
    • complexity: O(1) amortized time considering the typical user.
    • since: 6.0.0

    Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

    Returns ChainableCommander

  • Simulates the execution of a command by a user, without executing the command.

    • group: server
    • complexity: O(1).
    • since: 7.0.0

    Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Generates a pseudorandom, secure password that can be used to identify ACL users.

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "GENPASS"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Lists the ACL rules of a user.

    • group: server
    • complexity: O(N). Where N is the number of password, command and pattern rules that the user has.
    • since: 6.0.0

    Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Dumps the effective rules in ACL file format.

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Reloads the rules from the configured ACL file.

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "LOAD"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Lists recent security events generated due to ACL rules.

    • group: server
    • complexity: O(N) with N being the number of entries shown.
    • since: 6.0.0

    Parameters

    • subcommand: "LOG"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "LOG"
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "LOG"
    • reset: "RESET"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Saves the effective ACL rules in the configured ACL file.

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "SAVE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Creates and modifies an ACL user and its rules.

    • group: server
    • complexity: O(N). Where N is the number of rules provided.
    • since: 6.0.0

    Parameters

    • subcommand: "SETUSER"
    • username: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

    Returns ChainableCommander

  • Lists all ACL users.

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "USERS"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Returns the authenticated username of the current connection.

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "WHOAMI"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • aclBuffer(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): ChainableCommander
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
  • aclBuffer(subcommand: "GENPASS", callback?: Callback<Buffer>): ChainableCommander
  • aclBuffer(subcommand: "GENPASS", bits: string | number, callback?: Callback<Buffer>): ChainableCommander
  • aclBuffer(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<Buffer[]>): ChainableCommander
  • aclBuffer(subcommand: "LIST", callback?: Callback<Buffer[]>): ChainableCommander
  • aclBuffer(subcommand: "USERS", callback?: Callback<Buffer[]>): ChainableCommander
  • aclBuffer(subcommand: "WHOAMI", callback?: Callback<Buffer>): ChainableCommander
  • Appends a string to the value of a key. Creates the key if it doesn't exist.

    • group: string
    • complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by the server will double the free space available on every reallocation.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Signals that a cluster client is following an -ASK redirect.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • auth(password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • auth(username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • Authenticates the connection.

    • group: connection
    • complexity: O(N) where N is the number of passwords defined for the user
    • since: 1.0.0

    Parameters

    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Asynchronously rewrites the append-only file to disk.

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<string>

    Returns ChainableCommander

  • bitfield(key: RedisKey, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, getBlockToken: "GET", encoding: string | Buffer, offset: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, setBlockToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, incrbyBlockToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", setBlockToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", incrbyBlockToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", setBlockToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", incrbyBlockToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", setBlockToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): ChainableCommander
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", incrbyBlockToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): ChainableCommander
  • Performs arbitrary bitfield integer operations on strings.

    • group: bitmap
    • complexity: O(1) for each subcommand specified
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • getBlockToken: "GET"
    • encoding: string | Buffer
    • offset: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • setBlockToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • incrbyBlockToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • setBlockToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • incrbyBlockToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • setBlockToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • incrbyBlockToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • setBlockToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • incrbyBlockToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
    • since: 7.0.0

    Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns ChainableCommander

  • Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): ChainableCommander
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): ChainableCommander
  • Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise. Deletes the sorted set if the last element was popped.

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns ChainableCommander

  • Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns ChainableCommander

  • call(command: string, callback?: Callback<unknown>): ChainableCommander
  • call(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): ChainableCommander
  • call(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • call(...args: [command: string, ...args: (string | number | Buffer)[]]): ChainableCommander
  • Call arbitrary commands.

    redis.call('set', 'foo', 'bar') is the same as redis.set('foo', 'bar'), so the only case you need to use this method is when the command is not supported by ioredis.

    redis.call('set', 'foo', 'bar');
    redis.call('get', 'foo', (err, value) => {
    // value === 'bar'
    });

    Parameters

    • command: string
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • callBuffer(command: string, callback?: Callback<unknown>): ChainableCommander
  • callBuffer(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): ChainableCommander
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[]]): ChainableCommander
  • client(subcommand: "CACHING", yes: "YES", callback?: Callback<"OK">): ChainableCommander
  • client(subcommand: "CACHING", no: "NO", callback?: Callback<"OK">): ChainableCommander
  • client(...args: [subcommand: "CAPA", ...capabilities: (string | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "CAPA", ...capabilities: (string | Buffer)[]]): ChainableCommander
  • client(subcommand: "GETNAME", callback?: Callback<string>): ChainableCommander
  • client(subcommand: "GETREDIR", callback?: Callback<number>): ChainableCommander
  • client(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "ID", callback?: Callback<number>): ChainableCommander
  • client(subcommand: "INFO", callback?: Callback<string>): ChainableCommander
  • client(subcommand: "KILL", oldFormat: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", clientIdToken: "ID", clientId: string | number, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", primary: "PRIMARY", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", slave: "SLAVE", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", usernameToken: "USER", username: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", addrToken: "ADDR", addr: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", laddrToken: "LADDR", laddr: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", skipme: "SKIPME", yes: "YES", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", skipme: "SKIPME", no: "NO", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "KILL", maxageToken: "MAXAGE", maxage: string | number, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "LIST", callback?: Callback<unknown>): ChainableCommander
  • client(...args: [subcommand: "LIST", clientIdToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "LIST", clientIdToken: "ID", ...clientIds: (string | number)[]]): ChainableCommander
  • client(subcommand: "LIST", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", clientIdToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", clientIdToken: "ID", ...clientIds: (string | number)[]]): ChainableCommander
  • client(subcommand: "LIST", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", clientIdToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", clientIdToken: "ID", ...clientIds: (string | number)[]]): ChainableCommander
  • client(subcommand: "LIST", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", clientIdToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", clientIdToken: "ID", ...clientIds: (string | number)[]]): ChainableCommander
  • client(subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", clientIdToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", clientIdToken: "ID", ...clientIds: (string | number)[]]): ChainableCommander
  • client(subcommand: "NO-EVICT", on: "ON", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "NO-EVICT", off: "OFF", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "NO-TOUCH", on: "ON", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "NO-TOUCH", off: "OFF", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "PAUSE", timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • client(subcommand: "PAUSE", timeout: string | number, write: "WRITE", callback?: Callback<"OK">): ChainableCommander
  • client(subcommand: "PAUSE", timeout: string | number, all: "ALL", callback?: Callback<"OK">): ChainableCommander
  • client(subcommand: "REPLY", on: "ON", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "REPLY", off: "OFF", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "REPLY", skip: "SKIP", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "SETINFO", libnameToken: "LIB-NAME", libname: string | Buffer, callback?: Callback<string>): ChainableCommander
  • client(subcommand: "SETINFO", libverToken: "LIB-VER", libver: string | Buffer, callback?: Callback<string>): ChainableCommander
  • client(subcommand: "SETNAME", connectionName: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[]]): ChainableCommander
  • client(subcommand: "TRACKINGINFO", callback?: Callback<string>): ChainableCommander
  • client(subcommand: "UNBLOCK", clientId: string | number, callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "UNBLOCK", clientId: string | number, timeout: "TIMEOUT", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "UNBLOCK", clientId: string | number, error: "ERROR", callback?: Callback<unknown>): ChainableCommander
  • client(subcommand: "UNPAUSE", callback?: Callback<"OK">): ChainableCommander
  • clientBuffer(subcommand: "GETNAME", callback?: Callback<Buffer>): ChainableCommander
  • clientBuffer(subcommand: "INFO", callback?: Callback<Buffer>): ChainableCommander
  • clientBuffer(subcommand: "SETINFO", libnameToken: "LIB-NAME", libname: string | Buffer, callback?: Callback<Buffer>): ChainableCommander
  • clientBuffer(subcommand: "SETINFO", libverToken: "LIB-VER", libver: string | Buffer, callback?: Callback<Buffer>): ChainableCommander
  • clientBuffer(subcommand: "TRACKINGINFO", callback?: Callback<Buffer>): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...ranges: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...ranges: (string | number)[]]): ChainableCommander
  • cluster(subcommand: "BUMPEPOCH", callback?: Callback<"BUMPED" | "STILL">): ChainableCommander
  • cluster(subcommand: "COUNT-FAILURE-REPORTS", nodeId: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • cluster(subcommand: "COUNTKEYSINSLOT", slot: string | number, callback?: Callback<number>): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[]]): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...ranges: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): ChainableCommander
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...ranges: (string | number)[]]): ChainableCommander
  • cluster(subcommand: "FAILOVER", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "FAILOVER", force: "FORCE", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "FAILOVER", takeover: "TAKEOVER", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "FLUSHSLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): ChainableCommander
  • cluster(subcommand: "FORGET", nodeId: string | number | Buffer, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "GETKEYSINSLOT", slot: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • cluster(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "INFO", callback?: Callback<string>): ChainableCommander
  • cluster(subcommand: "KEYSLOT", key: string | Buffer, callback?: Callback<number>): ChainableCommander
  • cluster(subcommand: "LINKS", callback?: Callback<unknown[]>): ChainableCommander
  • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, clusterBusPort: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "MYID", callback?: Callback<string>): ChainableCommander
  • cluster(subcommand: "MYSHARDID", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "NODES", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "REPLICAS", nodeId: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "REPLICATE", nodeId: string | number | Buffer, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "RESET", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "RESET", hard: "HARD", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "RESET", soft: "SOFT", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SAVECONFIG", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SET-CONFIG-EPOCH", configEpoch: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, importingToken: "IMPORTING", importing: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, importingToken: "IMPORTING", importing: string | Buffer, timeoutToken: "TIMEOUT", timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, migratingToken: "MIGRATING", migrating: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, migratingToken: "MIGRATING", migrating: string | Buffer, timeoutToken: "TIMEOUT", timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeToken: "NODE", node: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeToken: "NODE", node: string | Buffer, timeoutToken: "TIMEOUT", timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", timeoutToken: "TIMEOUT", timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • cluster(subcommand: "SHARDS", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLAVES", nodeId: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", slotsrangeToken: "SLOTSRANGE", startSlot: string | number, endSlot: string | number, callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, limitToken: "LIMIT", limit: string | number, callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, limitToken: "LIMIT", limit: string | number, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOT-STATS", orderbyToken: "ORDERBY", metric: string | Buffer, limitToken: "LIMIT", limit: string | number, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • cluster(subcommand: "SLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): ChainableCommander
  • Assigns new hash slots to a node.

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

    Returns ChainableCommander

  • Assigns new hash slot ranges to a node.

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...ranges: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...ranges: (string | number)[]]

    Returns ChainableCommander

  • Advances the cluster config epoch.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "BUMPEPOCH"
    • Optional callback: Callback<"BUMPED" | "STILL">

    Returns ChainableCommander

  • Returns the number of active failure reports active for a node.

    • group: cluster
    • complexity: O(N) where N is the number of failure reports
    • since: 3.0.0

    Parameters

    • subcommand: "COUNT-FAILURE-REPORTS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Returns the number of keys in a hash slot.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "COUNTKEYSINSLOT"
    • slot: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Sets hash slots as unbound for a node.

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0

    Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

    Returns ChainableCommander

  • Sets hash slot ranges as unbound for a node.

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0

    Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...ranges: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...ranges: (string | number)[]]

    Returns ChainableCommander

  • Forces a replica to perform a manual failover of its primary.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FAILOVER"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "FAILOVER"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "FAILOVER"
    • takeover: "TAKEOVER"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Deletes all slots information from a node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FLUSHSLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns ChainableCommander

  • Removes a node from the nodes table.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FORGET"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns the key names in a hash slot.

    • group: cluster
    • complexity: O(N) where N is the number of requested keys
    • since: 3.0.0

    Parameters

    • subcommand: "GETKEYSINSLOT"
    • slot: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: cluster
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns information about the state of a node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns the hash slot for a key.

    • group: cluster
    • complexity: O(N) where N is the number of bytes in the key
    • since: 3.0.0

    Parameters

    • subcommand: "KEYSLOT"
    • key: string | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Returns a list of all TCP links to and from peer nodes.

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 7.0.0

    Parameters

    • subcommand: "LINKS"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Forces a node to handshake with another node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "MEET"
    • ip: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "MEET"
    • ip: string | Buffer
    • port: string | number
    • clusterBusPort: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns the ID of a node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "MYID"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns the shard ID of a node.

    • group: cluster
    • complexity: O(1)
    • since: 7.2.0

    Parameters

    • subcommand: "MYSHARDID"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the cluster configuration for a node.

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0

    Parameters

    • subcommand: "NODES"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Lists the replica nodes of a primary node.

    • group: cluster
    • complexity: O(N) where N is the number of replicas.
    • since: 5.0.0

    Parameters

    • subcommand: "REPLICAS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Configure a node as replica of a primary node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "REPLICATE"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Resets a node.

    • group: cluster
    • complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.
    • since: 3.0.0

    Parameters

    • subcommand: "RESET"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "RESET"
    • hard: "HARD"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "RESET"
    • soft: "SOFT"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Forces a node to save the cluster configuration to disk.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SAVECONFIG"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Sets the configuration epoch for a new node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SET-CONFIG-EPOCH"
    • configEpoch: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Binds a hash slot to a node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • importingToken: "IMPORTING"
    • importing: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • importingToken: "IMPORTING"
    • importing: string | Buffer
    • timeoutToken: "TIMEOUT"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • migratingToken: "MIGRATING"
    • migrating: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • migratingToken: "MIGRATING"
    • migrating: string | Buffer
    • timeoutToken: "TIMEOUT"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeToken: "NODE"
    • node: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeToken: "NODE"
    • node: string | Buffer
    • timeoutToken: "TIMEOUT"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • stable: "STABLE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • stable: "STABLE"
    • timeoutToken: "TIMEOUT"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns the mapping of cluster slots to shards.

    • group: cluster
    • complexity: O(N) where N is the total number of cluster nodes
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDS"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Lists the replica nodes of a primary node.

    • group: cluster
    • complexity: O(N) where N is the number of replicas.
    • since: 3.0.0

    Parameters

    • subcommand: "SLAVES"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Return an array of slot usage statistics for slots assigned to the current node.

    • group: cluster
    • complexity: O(N) where N is the total number of slots based on arguments. O(N*log(N)) with ORDERBY subcommand.
    • since: 8.0.0

    Parameters

    • subcommand: "SLOT-STATS"
    • slotsrangeToken: "SLOTSRANGE"
    • startSlot: string | number
    • endSlot: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the mapping of cluster slots to nodes.

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0

    Parameters

    • subcommand: "SLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns ChainableCommander

  • command(subcommand: "COUNT", callback?: Callback<unknown[]>): ChainableCommander
  • command(subcommand: "DOCS", callback?: Callback<unknown[]>): ChainableCommander
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]): ChainableCommander
  • command(subcommand: "GETKEYS", command: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • command(...args: [subcommand: "GETKEYS", command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • command(...args: [subcommand: "GETKEYS", command: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
  • command(subcommand: "GETKEYSANDFLAGS", command: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • command(...args: [subcommand: "GETKEYSANDFLAGS", command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • command(...args: [subcommand: "GETKEYSANDFLAGS", command: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
  • command(subcommand: "HELP", callback?: Callback<unknown[]>): ChainableCommander
  • command(subcommand: "INFO", callback?: Callback<unknown[]>): ChainableCommander
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]): ChainableCommander
  • command(subcommand: "LIST", callback?: Callback<unknown[]>): ChainableCommander
  • command(subcommand: "LIST", filterby: "FILTERBY", moduleNameToken: "MODULE", moduleName: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • command(subcommand: "LIST", filterby: "FILTERBY", categoryToken: "ACLCAT", category: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • command(subcommand: "LIST", filterby: "FILTERBY", patternToken: "PATTERN", pattern: string, callback?: Callback<unknown[]>): ChainableCommander
  • Returns a count of commands.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "COUNT"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns documentary information about one, multiple or all commands.

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 7.0.0

    Parameters

    • subcommand: "DOCS"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

    Returns ChainableCommander

  • Extracts the key names from an arbitrary command.

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 2.8.13

    Parameters

    • subcommand: "GETKEYS"
    • command: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "GETKEYS", command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "GETKEYS", command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Extracts the key names and access flags for an arbitrary command.

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 7.0.0

    Parameters

    • subcommand: "GETKEYSANDFLAGS"
    • command: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "GETKEYSANDFLAGS", command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "GETKEYSANDFLAGS", command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns information about one, multiple or all commands.

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 2.8.13

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns a list of command names.

    • group: server
    • complexity: O(N) where N is the total number of commands
    • since: 7.0.0

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • moduleNameToken: "MODULE"
    • moduleName: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • categoryToken: "ACLCAT"
    • category: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • patternToken: "PATTERN"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]): ChainableCommander
  • config(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • config(subcommand: "RESETSTAT", callback?: Callback<unknown>): ChainableCommander
  • config(subcommand: "REWRITE", callback?: Callback<unknown>): ChainableCommander
  • config(...args: [subcommand: "SET", ...data: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • config(...args: [subcommand: "SET", ...data: (string | number | Buffer)[]]): ChainableCommander
  • Returns the effective values of configuration parameters.

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0

    Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Resets the server's statistics.

    • group: server
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • subcommand: "RESETSTAT"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Persists the effective configuration to file.

    • group: server
    • complexity: O(1)
    • since: 2.8.0

    Parameters

    • subcommand: "REWRITE"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Sets configuration parameters in-flight.

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0

    Parameters

    • Rest ...args: [subcommand: "SET", ...data: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "SET", ...data: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Returns the number of keys in the database.

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<number>

    Returns ChainableCommander

  • debug(subcommand: string, callback?: Callback<unknown>): ChainableCommander
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[]]): ChainableCommander
  • Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • decrement: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Discards a transaction.

    • group: transactions
    • complexity: O(N), when N is the number of queued commands
    • since: 2.0.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns a serialized representation of the value stored at a key.

    • group: generic
    • complexity: O(1) to access the key and additional O(NM) to serialize it, where N is the number of objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1).
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns the given string.

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • message: string | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • eval(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • eval_ro(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • evalsha(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • evalsha_ro(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • exec(callback?: Callback<[error: Error, result: unknown][]>): Promise<[error: Error, result: unknown][]>
  • Executes all commands in a transaction.

    • group: transactions
    • complexity: Depends on commands in the transaction
    • since: 1.2.0

    Parameters

    • Optional callback: Callback<[error: Error, result: unknown][]>

    Returns Promise<[error: Error, result: unknown][]>

  • failover(callback?: Callback<"OK">): ChainableCommander
  • failover(millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(abort: "ABORT", callback?: Callback<"OK">): ChainableCommander
  • failover(abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): ChainableCommander
  • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • Starts a coordinated failover from a server to one of its replicas.

    • group: server
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • fcall(fun: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • fcall(...args: [fun: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • fcall_ro(fun: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • fcall_ro(...args: [fun: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<string>): ChainableCommander
  • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<string>): ChainableCommander
  • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<string>): ChainableCommander
  • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<string>): ChainableCommander
  • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<string>): ChainableCommander
  • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<Buffer>): ChainableCommander
  • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<Buffer>): ChainableCommander
  • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<Buffer>): ChainableCommander
  • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<Buffer>): ChainableCommander
  • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<Buffer>): ChainableCommander
  • Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.0

    Parameters

    • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

    Returns ChainableCommander

  • Returns members from a geospatial index that are within a distance from a coordinate.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.10

    Parameters

    • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

    Returns ChainableCommander

  • Queries a geospatial index for members within a distance from a member, optionally stores the result.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.0

    Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns ChainableCommander

  • Returns members from a geospatial index that are within a distance from a member.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.10

    Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns ChainableCommander

  • Queries a geospatial index for members inside an area of a box or a circle.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
    • since: 6.2.0

    Parameters

    Returns ChainableCommander

  • Parameters

    Returns ChainableCommander

  • Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
    • since: 6.2.0

    Parameters

    Returns ChainableCommander

  • Parameters

    Returns ChainableCommander

  • Returns a substring of the string stored at a key.

    • group: string
    • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
    • since: 2.4.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns the previous string value of a key after setting it to a new value.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.

    • group: hash
    • complexity: O(N) where N is the number of fields to be removed.
    • since: 2.0.0

    Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns ChainableCommander

  • hello(callback?: Callback<unknown[]>): ChainableCommander
  • hello(protover: string | number, callback?: Callback<unknown[]>): ChainableCommander
  • hello(protover: string | number, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • hello(protover: string | number, authToken: "AUTH", username: string | Buffer, password: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • hello(protover: string | number, authToken: "AUTH", username: string | Buffer, password: string | Buffer, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • Handshakes with the server.

    • group: connection
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • protover: string | number
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • protover: string | number
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • protover: string | number
    • authToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • protover: string | number
    • authToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Determines whether a field exists in a hash.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Returns all fields and values in a hash.

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<Record<string, string>>

    Returns ChainableCommander

  • Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • increment: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.

    • group: hash
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • increment: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<Buffer>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, novalues: "NOVALUES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • Iterates over fields and values of a hash.

    • group: hash
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • hscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, novalues: "NOVALUES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, novalues: "NOVALUES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • Sets the value of a field in a hash only when the field doesn't exist.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns all key names that match a pattern.

    • group: generic
    • complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
    • since: 1.0.0

    Parameters

    • pattern: string
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Returns the Unix timestamp of the last successful save to disk.

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<number>

    Returns ChainableCommander

  • latency(subcommand: "DOCTOR", callback?: Callback<string>): ChainableCommander
  • latency(subcommand: "GRAPH", event: string | Buffer, callback?: Callback<string>): ChainableCommander
  • latency(subcommand: "HELP", callback?: Callback<unknown[]>): ChainableCommander
  • latency(subcommand: "HISTOGRAM", callback?: Callback<unknown>): ChainableCommander
  • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]): ChainableCommander
  • latency(subcommand: "HISTORY", event: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • latency(subcommand: "LATEST", callback?: Callback<unknown[]>): ChainableCommander
  • latency(subcommand: "RESET", callback?: Callback<number>): ChainableCommander
  • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]): ChainableCommander
  • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[]]): ChainableCommander
  • Returns a human-readable latency analysis report.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "DOCTOR"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns a latency graph for an event.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "GRAPH"
    • event: string | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns the cumulative distribution of latencies of a subset or all commands.

    • group: server
    • complexity: O(N) where N is the number of commands with latency information being retrieved.
    • since: 7.0.0

    Parameters

    • subcommand: "HISTOGRAM"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns timestamp-latency samples for an event.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "HISTORY"
    • event: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns the latest latency samples for all events.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "LATEST"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Resets the latency data for one or more events.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "RESET"
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns an element from a list by its index.

    • group: list
    • complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • index: string | number
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • linsert(key: RedisKey, before: "BEFORE", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • linsert(key: RedisKey, after: "AFTER", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • Inserts an element before or after another element in a list.

    • group: list
    • complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • before: "BEFORE"
    • pivot: string | number | Buffer
    • element: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • after: "AFTER"
    • pivot: string | number | Buffer
    • element: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, callback?: Callback<number>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): ChainableCommander
  • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): ChainableCommander
  • Returns the index of matching elements in a list.

    • group: list
    • complexity: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.
    • since: 6.0.6

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • Optional callback: Callback<number[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • Optional callback: Callback<number[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number[]>

    Returns ChainableCommander

  • Prepends one or more elements to a list. Creates the key if it doesn't exist.

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 1.0.0

    Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Prepends one or more elements to a list only when the list exists.

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 2.2.0

    Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Returns a range of elements from a list.

    • group: list
    • complexity: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Removes elements from a list. Deletes the list if the last element was removed.

    • group: list
    • complexity: O(N+M) where N is the length of the list and M is the number of elements removed.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • count: string | number
    • element: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Sets the value of an element in a list by its index.

    • group: list
    • complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • index: string | number
    • element: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    • group: list
    • complexity: O(N) where N is the number of elements to be removed by the operation.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Outputs a memory problems report.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "DOCTOR"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns the allocator statistics.

    • group: server
    • complexity: Depends on how much memory is allocated, could be slow
    • since: 4.0.0

    Parameters

    • subcommand: "MALLOC-STATS"
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Asks the allocator to release memory.

    • group: server
    • complexity: Depends on how much memory is allocated, could be slow
    • since: 4.0.0

    Parameters

    • subcommand: "PURGE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns details about memory usage.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "STATS"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Estimates the memory usage of a key.

    • group: server
    • complexity: O(N) where N is the number of samples.
    • since: 4.0.0

    Parameters

    • subcommand: "USAGE"
    • key: RedisKey
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Parameters

    • subcommand: "USAGE"
    • key: RedisKey
    • countToken: "SAMPLES"
    • count: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • migrate(host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]): ChainableCommander
  • migrate(...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]): ChainableCommander
  • Atomically transfers a key from one instance to another.

    • group: generic
    • complexity: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
    • since: 2.6.0

    Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns ChainableCommander

  • module(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • module(subcommand: "LIST", callback?: Callback<unknown>): ChainableCommander
  • module(subcommand: "LOAD", path: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
  • module(subcommand: "LOADEX", path: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]): ChainableCommander
  • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]): ChainableCommander
  • module(subcommand: "UNLOAD", name: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • Returns helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns all loaded modules.

    • group: server
    • complexity: O(N) where N is the number of loaded modules.
    • since: 4.0.0

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Loads a module.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "LOAD"
    • path: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Loads a module using extended parameters.

    • group: server
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "LOADEX"
    • path: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

    Returns ChainableCommander

  • Unloads a module.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "UNLOAD"
    • name: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the internal encoding of an object.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "ENCODING"
    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the logarithmic access frequency counter of an object.

    • group: generic
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "FREQ"
    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: generic
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the time since the last access to an object.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "IDLETIME"
    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the reference count of a value of a key.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "REFCOUNT"
    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the expiration time of a key as a Unix milliseconds timestamp.

    • group: generic
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Internal commands for debugging HyperLogLog values.

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    • subcommand: string | Buffer
    • key: RedisKey
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • An internal command for testing HyperLogLog values.

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • psetex(key: RedisKey, milliseconds: string | number, value: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • milliseconds: string | number
    • value: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Listens for messages published to channels that match one or more patterns.

    • group: pubsub
    • complexity: O(N) where N is the number of patterns to subscribe to.
    • since: 2.0.0

    Parameters

    • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: string[]

    Returns ChainableCommander

  • psync(replicationid: string | number | Buffer, offset: string | number, callback?: Callback<unknown>): ChainableCommander
  • An internal command used in replication.

    • group: server
    • complexity: undefined
    • since: 2.8.0

    Parameters

    • replicationid: string | number | Buffer
    • offset: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): ChainableCommander
  • Posts a message to a channel.

    • group: pubsub
    • complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
    • since: 2.0.0

    Parameters

    • channel: string | Buffer
    • message: string | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • pubsub(subcommand: "CHANNELS", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "CHANNELS", pattern: string, callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "HELP", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "NUMPAT", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "NUMSUB", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]): ChainableCommander
  • pubsub(subcommand: "SHARDCHANNELS", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "SHARDCHANNELS", pattern: string, callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(subcommand: "SHARDNUMSUB", callback?: Callback<unknown[]>): ChainableCommander
  • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]): ChainableCommander
  • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]): ChainableCommander
  • Returns the active channels.

    • group: pubsub
    • complexity: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)
    • since: 2.8.0

    Parameters

    • subcommand: "CHANNELS"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CHANNELS"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: pubsub
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns a count of unique pattern subscriptions.

    • group: pubsub
    • complexity: O(1)
    • since: 2.8.0

    Parameters

    • subcommand: "NUMPAT"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns a count of subscribers to channels.

    • group: pubsub
    • complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels
    • since: 2.8.0

    Parameters

    • subcommand: "NUMSUB"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns the active shard channels.

    • group: pubsub
    • complexity: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDCHANNELS"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SHARDCHANNELS"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Returns the count of subscribers of shard channels.

    • group: pubsub
    • complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDNUMSUB"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

    Returns ChainableCommander

  • Returns a random key name from the database.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Enables read-only queries for a connection to a Valkey replica node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Enables read-write queries for a connection to a Valkey replica node.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • An internal command for configuring the replication stream.

    • group: server
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • replicaof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): ChainableCommander
  • replicaof(no: "NO", one: "ONE", callback?: Callback<"OK">): ChainableCommander
  • Configures a server as replica of another, or promotes it to a primary.

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • no: "NO"
    • one: "ONE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): ChainableCommander
  • Creates a key from the serialized representation of a value.

    • group: generic
    • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): ChainableCommander
  • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): ChainableCommander
  • An internal command for migrating keys in a cluster.

    • group: server
    • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
    • since: 3.0.0

    Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    Returns ChainableCommander

  • Appends one or more elements to a list. Creates the key if it doesn't exist.

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 1.0.0

    Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Appends an element to a list only when the list exists.

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 2.2.0

    Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns ChainableCommander

  • Synchronously saves the database(s) to disk.

    • group: server
    • complexity: O(N) where N is the total number of keys in all databases
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • scan(cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • Iterates over the key names in the database.

    • group: generic
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
    • since: 2.8.0

    Parameters

    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • scanBuffer(cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • Parameters

    • cursor: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns ChainableCommander

  • script(subcommand: "DEBUG", yes: "YES", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "DEBUG", sync: "SYNC", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "DEBUG", no: "NO", callback?: Callback<unknown>): ChainableCommander
  • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]): ChainableCommander
  • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]): ChainableCommander
  • script(subcommand: "FLUSH", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "KILL", callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "LOAD", script: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • script(subcommand: "SHOW", sha1: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • Sets the debug mode of server-side Lua scripts.

    • group: scripting
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • subcommand: "DEBUG"
    • yes: "YES"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "DEBUG"
    • sync: "SYNC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "DEBUG"
    • no: "NO"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Determines whether server-side Lua scripts exist in the script cache.

    • group: scripting
    • complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
    • since: 2.6.0

    Parameters

    • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

    Returns ChainableCommander

  • Removes all server-side Lua scripts from the script cache.

    • group: scripting
    • complexity: O(N) with N being the number of scripts in cache
    • since: 2.6.0

    Parameters

    • subcommand: "FLUSH"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: scripting
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Terminates a server-side Lua script during execution.

    • group: scripting
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • subcommand: "KILL"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Loads a server-side Lua script to the script cache.

    • group: scripting
    • complexity: O(N) with N being the length in bytes of the script body.
    • since: 2.6.0

    Parameters

    • subcommand: "LOAD"
    • script: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Show server-side Lua script in the script cache.

    • group: scripting
    • complexity: O(1).
    • since: 8.0.0

    Parameters

    • subcommand: "SHOW"
    • sha1: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Changes the selected database.

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • index: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • set(key: RedisKey, value: string | number | Buffer, callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<string>): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", callback?: Callback<"OK">): ChainableCommander
  • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<string>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<Buffer>): ChainableCommander
  • Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.

    • group: bitmap
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Sets the string value and expiration time of a key. Creates the key if it doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • seconds: string | number
    • value: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Set the string value of a key only when the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • setrange(key: RedisKey, offset: string | number, value: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.

    • group: string
    • complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • offset: string | number
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Determines whether a member belongs to a set.

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Sets a server as a replica of another, or promotes it to being a primary.

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Parameters

    • no: "NO"
    • one: "ONE"
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • Returns the slow log's entries.

    • group: server
    • complexity: O(N) where N is the number of entries returned
    • since: 2.2.12

    Parameters

    • subcommand: "GET"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "GET"
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the number of entries in the slow log.

    • group: server
    • complexity: O(1)
    • since: 2.2.12

    Parameters

    • subcommand: "LEN"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Clears all entries from the slow log.

    • group: server
    • complexity: O(N) where N is the number of entries in the slowlog
    • since: 2.2.12

    Parameters

    • subcommand: "RESET"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Sorts the elements in a list, a set, or a sorted set, optionally storing the result.

    • group: generic
    • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
    • since: 1.0.0

    Parameters

    Returns ChainableCommander

  • Parameters

    Returns ChainableCommander

  • sort_ro(key: RedisKey, callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[]]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[]]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): ChainableCommander
  • sort_ro(...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]): ChainableCommander
  • Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.

    • group: set
    • complexity: Without the count argument O(1); otherwise, O(N) where N is the value of the passed count.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • Post a message to a shard channel

    • group: pubsub
    • complexity: O(N) where N is the number of clients subscribed to the receiving shard channel.
    • since: 7.0.0

    Parameters

    • shardchannel: string | Buffer
    • message: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • sscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • sscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • Iterates over members of a set.

    • group: set
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • sscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • sscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • Listens for messages published to shard channels.

    • group: pubsub
    • complexity: O(N) where N is the number of shard channels to subscribe to.
    • since: 7.0.0

    Parameters

    • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: (string | Buffer)[]

    Returns ChainableCommander

  • Listens for messages published to channels.

    • group: pubsub
    • complexity: O(N) where N is the number of channels to subscribe to.
    • since: 2.0.0

    Parameters

    • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: (string | Buffer)[]

    Returns ChainableCommander

  • Returns a substring from a string value.

    • group: string
    • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • swapdb(index1: string | number, index2: string | number, callback?: Callback<"OK">): ChainableCommander
  • Swaps two databases.

    • group: server
    • complexity: O(N) where N is the count of clients watching or blocking on keys from both databases.
    • since: 4.0.0

    Parameters

    • index1: string | number
    • index2: string | number
    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • An internal command used in replication.

    • group: server
    • complexity: undefined
    • since: 1.0.0

    Parameters

    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Forgets about watched keys of a transaction.

    • group: transactions
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • Optional callback: Callback<"OK">

    Returns ChainableCommander

  • wait(numreplicas: string | number, timeout: string | number, callback?: Callback<number>): ChainableCommander
  • Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.

    • group: generic
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • numreplicas: string | number
    • timeout: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • waitaof(numlocal: string | number, numreplicas: string | number, timeout: string | number, callback?: Callback<unknown>): ChainableCommander
  • Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the primary and/or replicas.

    • group: generic
    • complexity: O(1)
    • since: 7.2.0

    Parameters

    • numlocal: string | number
    • numreplicas: string | number
    • timeout: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.

    • group: stream
    • complexity: O(1) for each message ID processed.
    • since: 5.0.0

    Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

    Returns ChainableCommander

  • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, justid: "JUSTID", callback?: Callback<unknown[]>): ChainableCommander
  • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<unknown[]>): ChainableCommander
  • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, justid: "JUSTID", callback?: Callback<unknown[]>): ChainableCommander
  • Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.

    • group: stream
    • complexity: O(1) if COUNT is small.
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • justid: "JUSTID"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • justid: "JUSTID"
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...args: RedisValue[]]): ChainableCommander
  • Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.

    • group: stream
    • complexity: O(log N) with N being the number of messages in the PEL of the consumer group.
    • since: 5.0.0

    Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...args: RedisValue[]]

    Returns ChainableCommander

  • Returns the number of messages after removing them from a stream.

    • group: stream
    • complexity: O(1) for each single item to delete in the stream, regardless of the stream size.
    • since: 5.0.0

    Parameters

    • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

    Returns ChainableCommander

  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, id: string | number | Buffer, entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, newId: "$", callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, newId: "$", entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, newId: "$", mkstream: "MKSTREAM", callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATE", key: RedisKey, group: string | Buffer, newId: "$", mkstream: "MKSTREAM", entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "CREATECONSUMER", key: RedisKey, group: string | Buffer, consumer: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "DELCONSUMER", key: RedisKey, group: string | Buffer, consumer: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "DESTROY", key: RedisKey, group: string | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "SETID", key: RedisKey, group: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "SETID", key: RedisKey, group: string | Buffer, id: string | number | Buffer, entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "SETID", key: RedisKey, group: string | Buffer, newId: "$", callback?: Callback<unknown>): ChainableCommander
  • xgroup(subcommand: "SETID", key: RedisKey, group: string | Buffer, newId: "$", entriesreadToken: "ENTRIESREAD", entriesread: string | number, callback?: Callback<unknown>): ChainableCommander
  • Creates a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Creates a consumer in a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "CREATECONSUMER"
    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Deletes a consumer from a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "DELCONSUMER"
    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Destroys a consumer group.

    • group: stream
    • complexity: O(N) where N is the number of entries in the group's pending entries list (PEL).
    • since: 5.0.0

    Parameters

    • subcommand: "DESTROY"
    • key: RedisKey
    • group: string | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Returns helpful text about the different subcommands.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Sets the last-delivered ID of a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): ChainableCommander
  • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): ChainableCommander
  • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): ChainableCommander
  • Returns the information and entries from a stream consumer group's pending entries list.

    • group: stream
    • complexity: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • group: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • consumer: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • minIdleTimeToken: "IDLE"
    • minIdleTime: string | number
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • minIdleTimeToken: "IDLE"
    • minIdleTime: string | number
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • consumer: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns ChainableCommander

  • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): ChainableCommander
  • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): ChainableCommander
  • Returns the messages from a stream within a range of IDs.

    • group: stream
    • complexity: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns ChainableCommander

  • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): ChainableCommander
  • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): ChainableCommander
  • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): ChainableCommander
  • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): ChainableCommander
  • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): ChainableCommander
  • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): ChainableCommander
  • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.

    • group: stream
    • complexity: undefined
    • since: 5.0.0

    Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): ChainableCommander
  • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): ChainableCommander
  • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): ChainableCommander
  • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): ChainableCommander
  • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): ChainableCommander
  • xreadgroup(...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): ChainableCommander
  • Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.

    • group: stream
    • complexity: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
    • since: 5.0.0

    Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns ChainableCommander

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns ChainableCommander

  • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): ChainableCommander
  • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): ChainableCommander
  • Returns the messages from a stream within a range of IDs in reverse order.

    • group: stream
    • complexity: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns ChainableCommander

  • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): ChainableCommander
  • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): ChainableCommander
  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns ChainableCommander

  • xsetid(key: RedisKey, lastId: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xsetid(key: RedisKey, lastId: string | number | Buffer, maxDeletedIdToken: "MAXDELETEDID", maxDeletedId: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, callback?: Callback<unknown>): ChainableCommander
  • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, maxDeletedIdToken: "MAXDELETEDID", maxDeletedId: string | number | Buffer, callback?: Callback<unknown>): ChainableCommander
  • An internal command for replicating stream values.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • maxDeletedIdToken: "MAXDELETEDID"
    • maxDeletedId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • maxDeletedIdToken: "MAXDELETEDID"
    • maxDeletedId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns ChainableCommander

  • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<Buffer>]): ChainableCommander
  • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]): ChainableCommander
  • Returns the count of members in a sorted set that have scores within a range.

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • zincrby(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<string>): ChainableCommander
  • Increments the score of a member in a sorted set.

    • group: sorted-set
    • complexity: O(log(N)) where N is the number of elements in the sorted set.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • member: string | number | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • zincrbyBuffer(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<Buffer>): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zlexcount(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • Returns the number of members in a sorted set within a lexicographical range.

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): ChainableCommander
  • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): ChainableCommander
  • Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

    • group: sorted-set
    • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

    • group: sorted-set
    • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrange(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a range of indexes.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, byscore: "BYSCORE", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangeBuffer(key: RedisKey, start: string | number | Buffer, stop: string | Buffer, bylex: "BYLEX", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[]>

    Returns ChainableCommander

  • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): ChainableCommander
  • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a lexicographical range.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrangebyscore(key: RedisKey, min: string | number, max: string | number, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a range of scores.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 1.0.5

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<number>): ChainableCommander
  • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): ChainableCommander
  • zremrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): ChainableCommander
  • Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optional callback: Callback<number>

    Returns ChainableCommander

  • zrevrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrevrange(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a range of indexes in reverse order.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<string[]>): ChainableCommander
  • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a lexicographical range in reverse order.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): ChainableCommander
  • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): ChainableCommander
  • Returns members in a sorted set within a range of scores in reverse order.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns ChainableCommander

  • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): ChainableCommander
  • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", limitToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, noscores: "NOSCORES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: string, elements: string[]]>): ChainableCommander
  • Iterates over members and scores of a sorted set.

    • group: sorted-set
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • noscores: "NOSCORES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • noscores: "NOSCORES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • noscores: "NOSCORES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • noscores: "NOSCORES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns ChainableCommander

  • zscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, noscores: "NOSCORES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, noscores: "NOSCORES", callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): ChainableCommander
  • Returns the score of a member in a sorted set.

    • group: sorted-set
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optional callback: Callback<string>

    Returns ChainableCommander

  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): ChainableCommander
  • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): ChainableCommander
  • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): ChainableCommander

Generated using TypeDoc